home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / ovqp / interp1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-05-30  |  5.6 KB  |  311 lines
  1. # include    <ingres.h>
  2. # include    <aux.h>
  3. # include    <symbol.h>
  4. # include    <tree.h>
  5. # include    "../decomp/globs.h"
  6. # include    <sccs.h>
  7. # include    <errors.h>
  8.  
  9. SCCSID(@(#)interp1.c    8.5    5/30/88)
  10.  
  11.  
  12. /*
  13. **    INTERP1.C
  14. **
  15. **    symbol I/O utility routines for OVQP interpreter.
  16. **
  17. */
  18.  
  19. /*
  20. ** GETSYMBOL
  21. **
  22. **    Gets (type, len, value) symbols from list
  23. **    A ptr to the list is advanced after
  24. **    call.  Symbols are moved to a target location
  25. **    (typically a slot on the interpreter's De.ov_stack).
  26. **    Legality of symbol type and length is checked.
  27. **    Returns        1  if no more symbols in list
  28. **            0 otherwise
  29. **
  30. */
  31.  
  32. getsymbol(ts, p)
  33. SYMBOL    *ts;        /* target location (on stack) */
  34. SYMBOL    ***p;        /* pointer to list */
  35. {
  36.     int            len;    /*length of target symbol*/
  37.     register union symvalue    *d;    /* ptr to data for target symbol */
  38.     register SYMBOL        *cp;    /* the item in the list */
  39.     register SYMBOL        *tops;    /* target location on stack */
  40.     register union symvalue    *val;
  41.     register STRKEEPER    *seen;    /* Have we seen an s? */
  42.     register char         *c;    /* For debugging */
  43.     int            start;  /* save the start pos of a string */
  44.  
  45.     seen = 0;
  46.     tops = ts;    /* copy stack pointer */
  47.     cp = **p;    /* get list pointer */
  48.     tops->start = -1;    /* initialize start to impossible value */
  49.  
  50. #    ifdef xOTR1
  51.     if (tTf(84, 0))
  52.     {
  53.         printf("GETSYM: ");
  54.         prsym(cp);
  55.     }
  56. #    endif
  57.  
  58.     if (tops >= (SYMBOL *) &De.ov_stack[STACKSIZ])
  59.         ov_err(STACKOVER);
  60.  
  61.     val = &cp->value;
  62.     /* decomp will put the s_var's value in the right place 
  63.      * if this is the case
  64.      */
  65.     if (cp->type == VAR || cp->type == S_VAR)
  66.     {
  67.         tops->type = val->sym_var.varfrmt;
  68.         len = tops->len = val->sym_var.varfrml;
  69.         d = (union symvalue *) val->sym_var.valptr;
  70.         seen = (STRKEEPER *) val->sym_var.varstr;
  71.         val->sym_var.varstr = 0;
  72.     }
  73.     else
  74.     {
  75.         tops->type = cp->type;
  76.         len = tops->len = cp->len;
  77.         len &= I1MASK;
  78.         d = &cp->value;
  79.     }
  80.     /* advance De.ov_qvect sequencing pointer p */
  81.     *p += 1;
  82.  
  83.     switch(tops->type)
  84.     {
  85.       case INT:
  86.         switch (len)
  87.         {
  88.           case 1:
  89.             tops->value.sym_data.i1type = d->sym_data.i1type;
  90.             break;
  91.           case 2:
  92.           case 4:
  93.             bmove((char *) d, (char *) &tops->value.sym_data, len);
  94.             break;
  95.  
  96.           default:
  97.             syserr("getsym:bad int len %d",len);
  98.         }
  99.         break;
  100.  
  101.       case FLOAT:
  102.         switch (len)
  103.         {
  104.           case 4:
  105.             tops->value.sym_data.f4type = d->sym_data.f4type;
  106.             break;
  107.  
  108.           case 8:
  109.             tops->value.sym_data.f8type = d->sym_data.f8type;
  110.             break;
  111.  
  112.           default:
  113.             syserr("getsym:bad FLOAT len %d",len);
  114.         }
  115.         break;
  116.  
  117.       case CHAR:
  118.       {
  119.         if ( seen )
  120.         {
  121.             if ((c = (char *)grabstring(seen,d, &len, &start)) != NULL)
  122.             {
  123.                 tops->len = len;
  124.             tops->value.sym_data.cptype = c;
  125.             /*tops->leavebl = 1; */
  126.             tops->start = start;
  127.             }
  128.             else
  129.             {
  130.             tops->value.sym_data.cptype = "\0";
  131.             tops->len = 0;
  132.             }
  133.         }
  134.         else
  135.         {
  136.             tops->value.sym_data.cptype = (char *)d;
  137.         /*  seen = 0; */
  138.         }
  139.         break;
  140.     }
  141.  
  142.       case AOP:
  143.       case BOP:
  144.       case UOP:
  145.       case COP:
  146.         tops->value.sym_op.opno = d->sym_op.opno;
  147.         break;
  148.  
  149.       case RESDOM:
  150.         tops->value.sym_resdom.resno = d->sym_resdom.resno;
  151.         break;
  152.  
  153.       case AND:
  154.       case OR:
  155.         break;
  156.  
  157.       case AGHEAD:
  158.       case BYHEAD:
  159.       case ROOT:
  160.       case QLEND:
  161.         return (1);    /* all these are delimitors between lists */
  162.  
  163.       default:
  164.         syserr("getsym:bad type %d", tops->type);
  165.     }
  166.     return(0);
  167. }
  168. /*
  169. **  TOUT
  170. **
  171. **    Copies a symbol value into the Output tuple buffer.
  172. **     Used to write target
  173. **    list elements or aggregate values into the output tuple.
  174. */
  175.  
  176. tout(s, offp, rlen)
  177. register SYMBOL    *s;
  178. char        *offp;
  179. int        rlen;
  180. {
  181.     register int    i;
  182.     register char    *p;
  183.     int        slen;
  184.  
  185. #    ifdef xOTR1
  186.     if (tTf(84, 3))
  187.     {
  188.         printf("TOUT: s=");
  189.         prstack(s);
  190.         printf("  offset=%d, rlen=%d\n", offp-De.ov_outtup, rlen);
  191.     }
  192. #    endif
  193.     if (s->type == CHAR)
  194.     {
  195.         slen = s->len & I1MASK;
  196.         rlen &= I1MASK;
  197.         i = rlen - slen;    /* compute difference between sizes */
  198.         if (i <= 0)
  199.         {
  200.             bmove(s->value.sym_data.cptype, offp, rlen);
  201.         }
  202.         else
  203.         {
  204.             p = s->value.sym_data.cptype;
  205.             bmove(p, offp, slen);
  206.             p = &offp[slen];
  207.             while (i--)
  208.                 *p++ = ' ';    /* blank out remainder */
  209.         }
  210.     }
  211.     else
  212.     {
  213.         bmove((char *)&s->value, offp, rlen);
  214.     }
  215. }
  216.  
  217. /*
  218. **     RCVT -    convert a symbol to a given type 
  219. **
  220. **    Parameters:
  221. **        tos -  the symbol
  222. **        restype - the type to convert it to
  223. **        reslen - the length of the type
  224. **
  225. **    Trace Flags:
  226. **        84.6
  227. **
  228. **    Called by:
  229. **        interpret()
  230. **        setallkey()
  231. **        typecoerce()
  232. */
  233. rcvt(tos, restype, reslen)
  234. register SYMBOL    *tos;
  235. int        restype, reslen;
  236. {
  237.     register int    rtype, rlen;
  238.     int        stype, slen;
  239.  
  240.     rtype = restype;
  241.     rlen = reslen;
  242.     stype = tos->type;
  243.     slen= tos->len;
  244. #    ifdef xOTR1
  245.     if (tTf(84, 6))
  246.     {
  247.         printf("RCVT:type=");
  248.         xputchar(rtype);
  249.         printf("%3d, tos=", rlen);
  250.         prstack(tos);
  251.     }
  252. #    endif
  253.  
  254.     if (rtype != stype)
  255.     {
  256.         if (rtype == CHAR || stype == CHAR)
  257.             ov_err(BADCONV);    /* bad char to numeric conversion requested */
  258.         if (rtype == FLOAT)
  259.         {
  260.             itof(tos);
  261.             if (rlen == 4)
  262.                 f8tof4(tos);
  263.         }
  264.         else
  265.         {
  266.             if (rlen == 4)
  267.                 ftoi4(tos);
  268.             else
  269.                 ftoi2(tos);
  270.             if (rlen == 1)
  271.                 tos->value.sym_data.i1type =
  272.                   tos->value.sym_data.i2type;
  273.         }
  274.         tos->len = rlen;
  275.     }
  276.  
  277.     else
  278.     {
  279.         if (rtype != CHAR && rlen != slen)
  280.         {
  281.             if (rtype == INT)
  282.             {
  283.                 if (slen == 1)
  284.                     tos->value.sym_data.i2type =
  285.                       tos->value.sym_data.i1type;
  286.                 if (rlen == 4)
  287.                     i2toi4(tos);
  288.                 else if (slen == 4)
  289.                         i4toi2(tos);
  290.                 if (rlen == 1)
  291.                     tos->value.sym_data.i1type =
  292.                       tos->value.sym_data.i2type;
  293.             } else if (rlen == 4)
  294.                 tos->value.sym_data.f4type =
  295.                   tos->value.sym_data.f8type;
  296.             else
  297.                 tos->value.sym_data.f8type =
  298.                   tos->value.sym_data.f4type;
  299.  
  300.             tos->len = rlen;    /* handles conversion to i1 or f4 */
  301.         }
  302.     }
  303. #    ifdef xOTR3
  304.     if (tTf(84, 6))
  305.     {
  306.         printf("RCVT rets: symbol: ");
  307.         prsym(tos);
  308.     }
  309. #    endif
  310. }
  311.